<!DOCTYPE html>
<html prefix="og: http://ogp.me/ns# article: http://ogp.me/ns/article# " lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>10-from-the-perceptron-to-artificial-neural-networks | 绿萝间</title>
<link href="../assets/css/all-nocdn.css" rel="stylesheet" type="text/css">
<link href="../assets/css/ipython.min.css" rel="stylesheet" type="text/css">
<link href="../assets/css/nikola_ipython.css" rel="stylesheet" type="text/css">
<meta name="theme-color" content="#5670d4">
<meta name="generator" content="Nikola (getnikola.com)">
<link rel="alternate" type="application/rss+xml" title="RSS" href="../rss.xml">
<link rel="canonical" href="https://muxuezi.github.io/posts/10-from-the-perceptron-to-artificial-neural-networks.html">
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
    tex2jax: {
        inlineMath: [ ['$','$'], ["\\(","\\)"] ],
        displayMath: [ ['$$','$$'], ["\\[","\\]"] ],
        processEscapes: true
    },
    displayAlign: 'center', // Change this to 'center' to center equations.
    "HTML-CSS": {
        styles: {'.MathJax_Display': {"margin": 0}}
    }
});
</script><!--[if lt IE 9]><script src="../assets/js/html5.js"></script><![endif]--><meta name="author" content="Tao Junjie">
<link rel="prev" href="dlott-15078-2015-07-08-report.html" title="大乐透15078期(2015-07-08)数据分析报告" type="text/html">
<link rel="next" href="0-perface.html" title="0-perface" type="text/html">
<meta property="og:site_name" content="绿萝间">
<meta property="og:title" content="10-from-the-perceptron-to-artificial-neural-networks">
<meta property="og:url" content="https://muxuezi.github.io/posts/10-from-the-perceptron-to-artificial-neural-networks.html">
<meta property="og:description" content="从感知器到人工神经网络¶








在第8章，感知器里，我们介绍了感知器，一种线性模型用来做二元分类。感知器不是一个通用函数近似器；它的决策边界必须是一个超平面。上一章里面介绍的支持向量机，用核函数修正了感知器的不足，将特征向量有效的映射到更高维的空间使得样本成为线性可分的数据集。本章，我们将介绍人工神经网络（artificial neural networks，ANN），一种用于强大的非线">
<meta property="og:type" content="article">
<meta property="article:published_time" content="2015-07-09T15:19:44+08:00">
<meta property="article:tag" content="CHS">
<meta property="article:tag" content="ipython">
<meta property="article:tag" content="Machine Learning">
<meta property="article:tag" content="Python">
</head>
<body>
<a href="#content" class="sr-only sr-only-focusable">Skip to main content</a>

<!-- Menubar -->

<nav class="navbar navbar-inverse navbar-static-top"><div class="container">
<!-- This keeps the margins nice -->
        <div class="navbar-header">
            <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-navbar" aria-controls="bs-navbar" aria-expanded="false">
            <span class="sr-only">Toggle navigation</span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
            </button>
            <a class="navbar-brand" href="https://muxuezi.github.io/">

                <span id="blog-title">绿萝间</span>
            </a>
        </div>
<!-- /.navbar-header -->
        <div class="collapse navbar-collapse" id="bs-navbar" aria-expanded="false">
            <ul class="nav navbar-nav">
<li>
<a href="../archive.html">Archive</a>
                </li>
<li>
<a href="../categories/">Tags</a>
                </li>
<li>
<a href="../rss.xml">RSS feed</a>

                
            </li>
</ul>
<ul class="nav navbar-nav navbar-right">
<li>
    <a href="10-from-the-perceptron-to-artificial-neural-networks.ipynb" id="sourcelink">Source</a>
    </li>

                
            </ul>
</div>
<!-- /.navbar-collapse -->
    </div>
<!-- /.container -->
</nav><!-- End of Menubar --><div class="container" id="content" role="main">
    <div class="body-content">
        <!--Body content-->
        <div class="row">
            
            
<article class="post-text h-entry hentry postpage" itemscope="itemscope" itemtype="http://schema.org/Article"><header><h1 class="p-name entry-title" itemprop="headline name"><a href="#" class="u-url">10-from-the-perceptron-to-artificial-neural-networks</a></h1>

        <div class="metadata">
            <p class="byline author vcard"><span class="byline-name fn">
                    Tao Junjie
            </span></p>
            <p class="dateline"><a href="#" rel="bookmark"><time class="published dt-published" datetime="2015-07-09T15:19:44+08:00" itemprop="datePublished" title="2015-07-09 15:19">2015-07-09 15:19</time></a></p>
            
        <p class="sourceline"><a href="10-from-the-perceptron-to-artificial-neural-networks.ipynb" id="sourcelink">Source</a></p>

        </div>
        

    </header><div class="e-content entry-content" itemprop="articleBody text">
    <div tabindex="-1" id="notebook" class="border-box-sizing">
    <div class="container" id="notebook-container">

<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="从感知器到人工神经网络">从感知器到人工神经网络<a class="anchor-link" href="10-from-the-perceptron-to-artificial-neural-networks.html#%E4%BB%8E%E6%84%9F%E7%9F%A5%E5%99%A8%E5%88%B0%E4%BA%BA%E5%B7%A5%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C">¶</a>
</h2>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>在<em>第8章，感知器</em>里，我们介绍了感知器，一种线性模型用来做二元分类。感知器不是一个通用函数近似器；它的决策边界必须是一个超平面。上一章里面介绍的支持向量机，用核函数修正了感知器的不足，将特征向量有效的映射到更高维的空间使得样本成为线性可分的数据集。本章，我们将介绍人工神经网络（artificial neural networks，ANN），一种用于强大的非线性回归和分类模型，用新的策略来克服感知器的缺点。</p>
<!-- TEASER_END-->
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>如果把感知器比喻成一个神经元，那么人工神经网络，即神经网，就是一个大脑。人脑就是由十几亿的神经元和上千亿的突触组成，人工神经网络是一种感知器或其他人工神经的有向图。这个图的边带有权重，这些权重是模型需要学习的参数。</p>
<p>有许多著作整本书描述人工神经网络；本章主要是对它的结构和训练方法进行介绍。目前scikit-learn的版本是0.16.1，在2014年Google Summer的项目中，多层感知器已经被作者实现，并提交在scikit-learn 0.15.1版本中，只是还没有被合并到scikit-learn。在未来的scikit-learn新版本中可能会原封不动的合并多层感知器的实现。也有一些神经网络模型的Python库，比如<a href="https://github.com/pybrain/pybrain">PyBrain</a>，<a href="https://github.com/lisa-lab/pylearn2">Pylearn2</a>和<a href="https://github.com/aigamedev/scikit-neuralnetwork">scikit-neuralnetwork</a>等。</p>

</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="非线性决策边界">非线性决策边界<a class="anchor-link" href="10-from-the-perceptron-to-artificial-neural-networks.html#%E9%9D%9E%E7%BA%BF%E6%80%A7%E5%86%B3%E7%AD%96%E8%BE%B9%E7%95%8C">¶</a>
</h3>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>在<em>第8章，感知器</em>里，我们介绍过布尔函数如AND（与），OR（或）和NAND（与非）可以用感知器近似，而XOR（异或）作为线性不可分函数不能被近似，如下图所示：</p>
<p><img src="mlslpic/10.1%20boolean.png" alt="boolean"></p>
<p>让我们深入研究XOR来感受一下人工神经网络的强大。AND是两个输入均为1结果才为1，OR是两个输入至少有1个1结果即为1。XOR与它们不同，XOR是当两个输入中有且仅有1个1结果才为1。我们把XOR输出为1的两个输入看出是两个条件均为真。第一个条件是至少有1个输入为1，这与OR的条件相同。第二个条件是两个输入不都为1，这与NAND的条件相同。我们可以通过处理OR和NAND的输入，生成同样输出的XOR，然后用AND验证两个函数的输出是否均为1。也就是说，OR，NAND和AND可以组合生成同样结果的XOR。</p>
<p>下面是XOR，OR，NAND和AND四种函数有两个输入A和B时的输出真值表。从这个表我们可以检验OR，NAND和AND组合函数的输出，与同样输入的XOR输出相同:</p>
<table>
<thead><tr>
<th style="text-align:center">A</th>
<th style="text-align:center">B</th>
<th style="text-align:center">A AND B</th>
<th style="text-align:center">A NAND B</th>
<th style="text-align:center">A OR B</th>
<th style="text-align:center">A XOR B</th>
</tr></thead>
<tbody>
<tr>
<td style="text-align:center">0</td>
<td style="text-align:center">0</td>
<td style="text-align:center">0</td>
<td style="text-align:center">1</td>
<td style="text-align:center">0</td>
<td style="text-align:center">0</td>
</tr>
<tr>
<td style="text-align:center">0</td>
<td style="text-align:center">1</td>
<td style="text-align:center">0</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
</tr>
<tr>
<td style="text-align:center">1</td>
<td style="text-align:center">0</td>
<td style="text-align:center">0</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
</tr>
<tr>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
<td style="text-align:center">0</td>
<td style="text-align:center">1</td>
<td style="text-align:center">0</td>
</tr>
</tbody>
</table>
<table>
<thead><tr>
<th style="text-align:center">A</th>
<th style="text-align:center">B</th>
<th style="text-align:center">A OR B</th>
<th style="text-align:center">A NAND B</th>
<th style="text-align:center">(A OR B) AND (A NAND B)</th>
</tr></thead>
<tbody>
<tr>
<td style="text-align:center">0</td>
<td style="text-align:center">0</td>
<td style="text-align:center">0</td>
<td style="text-align:center">1</td>
<td style="text-align:center">0</td>
</tr>
<tr>
<td style="text-align:center">0</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
</tr>
<tr>
<td style="text-align:center">1</td>
<td style="text-align:center">0</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
</tr>
<tr>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
<td style="text-align:center">1</td>
<td style="text-align:center">0</td>
<td style="text-align:center">0</td>
</tr>
</tbody>
</table>
<p>我们不使用单个感知器来表示XOR，而将建立一个具有多人工神经元的人工神经网络，每个神经元都近似一个线性函数。每个样本的特征表述都被输入到两个神经元：一个NAND神经元和一个OR神经元。这些神经元的输出将连接到第三个AND神经元上，测试XOR的条件是否为真。</p>

</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="前馈与反馈人工神经网络">前馈与反馈人工神经网络<a class="anchor-link" href="10-from-the-perceptron-to-artificial-neural-networks.html#%E5%89%8D%E9%A6%88%E4%B8%8E%E5%8F%8D%E9%A6%88%E4%BA%BA%E5%B7%A5%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C">¶</a>
</h3>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>人工神经网络由三个组成部分。第一个组成部分是架构（architecture），或称为拓扑结构（topology），描述神经元的层次与连接神经元的结构。第二个组成部分是神经网络使用的激励函数。第三个组成部分是找出最优权重值的学习算法。</p>
<p>人工神经网络主要分为两种类型。前馈人工神经网络（Feedforward neural networks）是最常用的神经网络类型，一般定义为有向无环图。信号只能沿着最终输入的那个方向传播。另一种类型是反馈人工神经网络（feedback neural networks），也称递归神经网络（recurrent neural networks），网络图中有环。反馈环表示网络的一种内部状态，随着不同时间内输入条件的改变，网络的行为也会发生变化。反馈人工神经网络的临时状态让它们适合处理涉及连续输入的问题。因为目前scikit-learn没有实现反馈人工神经网络，本文只介绍前馈人工神经网络。</p>

</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h4 id="多层感知器">多层感知器<a class="anchor-link" href="10-from-the-perceptron-to-artificial-neural-networks.html#%E5%A4%9A%E5%B1%82%E6%84%9F%E7%9F%A5%E5%99%A8">¶</a>
</h4>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>多层感知器（multilayer perceptron，MLP）是最流行的人工神经网络之一。它的名称不太恰当，多层感知器并非指单个带有多个层次的感知器，而是指可以是感知器的人工神经元组成的多个层次。MPL的层次结构是一个有向无环图。通常，每一层都全连接到下一层，某一层上的每个人工神经元的输出成为下一层若干人工神经元的输入。MLP至少有三层人工神经元。</p>
<p>输入层（input layer）由简单的输入人工神经元构成。每个输入神经元至少连接一个隐藏层（hidden layer）的人工神经元。隐藏层表示潜在的变量；层的输入和输出都不会出现在训练集中。隐藏层后面连接的是输出层（output layer）。下图所示的三层架构的多层感知器。带有<strong>+1</strong>标签的是常误差项神经元，大多数结构图中都不会画出来。</p>
<p><img src="mlslpic/10.2%20mlp3layers.png" alt="mlp3layers"></p>
<p>隐藏层中的人工神经元，也称单元（units）通常用非线性激励函数，如双曲正切函数（hyperbolic tangent function）和逻辑函数（logistic function），公式如下所示：</p>
$$f(x) = tanh(x)$$$$f(x) = \frac 1 {1+e^{-x}}$$<p>和其他的监督模型一样，我们的目标是找到成本函数最小化的权重值。通常，MLP的成本函数是残差平方和的均值，计算公式如下所示，其中的$m$表示训练样本的数量：</p>
$$MSE = \frac 1 m \sum_{i=1}^m{(y_i-f(x_i))^2}$$
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h4 id="成本函数最小化">成本函数最小化<a class="anchor-link" href="10-from-the-perceptron-to-artificial-neural-networks.html#%E6%88%90%E6%9C%AC%E5%87%BD%E6%95%B0%E6%9C%80%E5%B0%8F%E5%8C%96">¶</a>
</h4>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>反向传播（backpropagation）算法经常用来连接优化算法求解成本函数最小化问题，比如梯度下降法。这个算法名称是反向（back）和传播（propagation）的合成词，是指误差在网络层的流向。理论上，反向传播可以用于训练具有任意层、任意数量隐藏单元的前馈人工神经网络，但是计算能力的实际限制会约束反向传播的能力。</p>
<p>反向传播与梯度下降法类似，根据成本函数的梯度变化不断更新模型参数。与我们前面介绍过的线性模型不同，神经网络包含不可见的隐藏单元；我们不能从训练集中找到它们。如果我们找不到这些隐藏单元，我们也就不能计算它们的误差，不能计算成本函数的梯度，进而无法求出权重值。如果一个随机变化是某个权重降低了成本函数值，那么我们保留这个变化，就可能同时改变另一个权重的值。这种做法有个明显的问题，就是其计算成本过高。而反向传播算法提供了一种有效的解决方法。</p>
<p>我们将用反向传播逐步来训练一个前馈人工神经网络。这个网络与两个输入单元，两个隐藏层分别有三个隐藏单元，两个输出单元。输入单元与第一个隐藏层的三个隐藏单元<code>Hidden1</code>，<code>Hidden2</code>和<code>Hidden3</code>全连接。单元之间连接的边开始用很小的随机数表示权重。</p>

</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h4 id="前向传播">前向传播<a class="anchor-link" href="10-from-the-perceptron-to-artificial-neural-networks.html#%E5%89%8D%E5%90%91%E4%BC%A0%E6%92%AD">¶</a>
</h4>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>在前向传播（forward propagation）阶段，特征变量被输入到网络，然后传播到下一层产生输出激励（activation）。首先，我们计算<code>Hidden1</code>单元的激励。我们找到<code>Hidden1</code>单元的的加权和，然后用激励函数处理输入的加权和。注意<code>Hidden1</code>单元会收到一个常误差项输入单元，并没有在下图中画出。其中$g(x)$是一个激励函数：</p>
<p><img src="mlslpic/10.3%20forwardpropagation1.png" alt="forwardpropagation1"></p>
<p>然后，我们计算第二个隐藏单元<code>Hidden2</code>。和<code>Hidden1</code>类似，它也会收到一个常误差项输入单元。我们计算输入单元的加权和，或成为预激励，经过激励函数处理的激励如下图所示：</p>
<p><img src="mlslpic/10.4%20forwardpropagation2.png" alt="forwardpropagation2"></p>
<p>同理，我们计算第三个隐藏单元<code>Hidden3</code>的激励：</p>
<p><img src="mlslpic/10.5%20forwardpropagation3.png" alt="forwardpropagation3"></p>
<p>第一个隐藏层三个隐藏单元的激励计算完之后，我们再处理第二个隐藏层。本例中，第一个隐藏层第一个隐藏层到第二个隐藏层。与第一个隐藏层三个隐藏单元计算过程类似，都有一个常误差项输入单元，并没有在图中画出，我们计算<code>Hidden4</code>的激励如下图所示：</p>
<p><img src="mlslpic/10.6%20forwardpropagation4.png" alt="forwardpropagation4"></p>
<p>按照同样方法计算<code>Hidden5</code>和<code>Hidden6</code>的激励。当第二个隐藏层三个隐藏单元的激励计算完成后，我们计算输出层。<code>Output1</code>的激励是第二个隐藏层三个隐藏单元的激励的加权和经过激励函数处理的结果。类似与隐藏单元，有一个常误差项的输入单元，如下图所示：</p>
<p><img src="mlslpic/10.7%20forwardpropagation5.png" alt="forwardpropagation5"></p>
<p>同理，我们计算第二个输出单元<code>Output2</code>的激励：</p>
<p><img src="mlslpic/10.8%20forwardpropagation6.png" alt="forwardpropagation6"></p>
<p>计算完神经网络中所有单元的激励之后，我们就完成了前向传播过程。用这些随机生成的权重值是不可能很好的近似网络的真实函数的。我们必须更新权重值来生成一个更好的近似函数。</p>

</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h4 id="反向传播">反向传播<a class="anchor-link" href="10-from-the-perceptron-to-artificial-neural-networks.html#%E5%8F%8D%E5%90%91%E4%BC%A0%E6%92%AD">¶</a>
</h4>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>我们把输出单元计算的误差作为网络误差。隐藏单元表示不可见的变量；没有数据可以进行对照，因此我们无法度量隐藏单元。为了更新权重，我们必须把网络的误差反向传回。于是，我们先从<code>Output1</code>输出单元开始。其误差等于真实值与预测值的差，乘以激励函数对<code>Output1</code>输出单元的偏导数：</p>
<p><img src="mlslpic/10.9%20backpropagation1.png" alt="backpropagation1"></p>
<p>同理，我们计算第二个输出单元<code>Output2</code>的误差：</p>
<p><img src="mlslpic/10.10%20backpropagation2.png" alt="backpropagation2"></p>
<p>算完输出层的误差之后，我们把误差传回第二个隐藏层。首先，我们计算<code>Hidden4</code>的误差。把<code>Output1</code>的误差乘以连接<code>Hidden4</code>与<code>Output1</code>的权重，再<code>Output2</code>的误差乘以连接<code>Hidden4</code>与<code>Output2</code>的权重，再把它们相加就得到了<code>Hidden4</code>的误差：</p>
<p><img src="mlslpic/10.11%20backpropagation3.png" alt="backpropagation3"></p>
<p>同理，我们计算隐藏单元<code>Hidden5</code>的误差：</p>
<p><img src="mlslpic/10.12%20backpropagation4.png" alt="backpropagation4"></p>
<p>同理，我们计算隐藏单元<code>Hidden6</code>的误差：</p>
<p><img src="mlslpic/10.13%20backpropagation5.png" alt="backpropagation5"></p>
<p>算完第二个隐藏层的误差之后，同理把误差传回第一个隐藏层。<code>Hidden1</code>的误差就是激励函数对<code>Hidden1</code>隐藏单元的偏导数乘以第二隐藏层加权误差和，如下图所示：</p>
<p><img src="mlslpic/10.14%20backpropagation6.png" alt="backpropagation6"></p>
<p>同理，我们计算隐藏单元<code>Hidden2</code>的误差：</p>
<p><img src="mlslpic/10.15%20backpropagation7.png" alt="backpropagation7"></p>
<p>同理，我们计算隐藏单元<code>Hidden3</code>的误差：</p>
<p><img src="mlslpic/10.16%20backpropagation8.png" alt="backpropagation8"></p>
<p>算完第一个隐藏层的误差之后，我们用这些误差来升级权重值。首先升级连接输入单元与<code>Hidden1</code>的边的权重，以及连接常误差项与<code>Hidden1</code>的边的权重。我们将连接<code>Input1</code>与<code>Hidden1</code>的边的权重<code>Weight1</code>增加学习速率，<code>Hidden1</code>的误差以及<code>Input1</code>的值的乘积。</p>
<p>按同样的方法处理权重<code>Weight2</code>，我们把学习速率，<code>Hidden1</code>的误差以及<code>Input2</code>的值的乘积增加到<code>Weight2</code>。最后，我们计算常误差项输入的权重，把学习速率，<code>Hidden1</code>的误差以及常误差项的值1的乘积增加到常误差项输入的权重，如下图所示：</p>
<p><img src="mlslpic/10.17%20backpropagation9.png" alt="backpropagation9"></p>
<p>同理，我们升级连接输入单元与<code>Hidden2</code>的边的权重，以及连接常误差项与<code>Hidden2</code>的边的权重：</p>
<p><img src="mlslpic/10.18%20backpropagation10.png" alt="backpropagation10"></p>
<p>同理，我们升级连接输入单元与<code>Hidden3</code>的边的权重，以及连接常误差项与<code>Hidden3</code>的边的权重：</p>
<p><img src="mlslpic/10.19%20backpropagation11.png" alt="backpropagation11"></p>
<p>输入层与第一隐藏层之间边的权重全部更新之后，我们可以用同样的方法计算第一隐藏层与第二隐藏层直接边的权重。我们计算权重<code>Weight7</code>，把学习速率，<code>Hidden4</code>的误差以及<code>Hidden1</code>的值的乘积增加到<code>Weight7</code>。同样的方法计算<code>Weight8</code>与<code>Weight15</code>：</p>
<p><img src="mlslpic/10.20%20backpropagation12.png" alt="backpropagation12"></p>
<p>连接<code>Hidden5</code>与<code>Hidden6</code>的边的权重按同样的方法升级。升级完两个隐藏层之间的权重之后，我们就来升级第二隐藏层与输出层之间的权重。用同样的方法升级<code>Weight16</code>到<code>Weight21</code>的权重：</p>
<p><img src="mlslpic/10.21%20backpropagation13.png" alt="backpropagation13"></p>
<p><img src="mlslpic/10.22%20backpropagation14.png" alt="backpropagation14"></p>
<p>把学习速率，<code>Output2</code>的误差以及<code>Hidden6</code>的激励的乘积增加到<code>Weight21</code>之后，这个阶段网络权重的更新工作就完成了。我们现在可以用心的权重再运行一遍前向传播，成本函数的值应该会减少。重复这个过程直到模型收敛或者停止条件得到了满足为止。与之前我们介绍过的线性模型不同，反向传播不能优化凸函数。反向传播可能用某个局部最小值的参数值达到收敛，而不是全局最小值。实际应用中，局部最小值通常可以解决问题。</p>

</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="用多层感知器近似XOR函数">用多层感知器近似XOR函数<a class="anchor-link" href="10-from-the-perceptron-to-artificial-neural-networks.html#%E7%94%A8%E5%A4%9A%E5%B1%82%E6%84%9F%E7%9F%A5%E5%99%A8%E8%BF%91%E4%BC%BCXOR%E5%87%BD%E6%95%B0">¶</a>
</h3>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>让我们训练一个多层感知器来近似XOR函数。目前，scikit-learn的0.16.1版本还没有合并，作者在其github上提供了单独的MLP模块<a href="https://github.com/IssamLaradji/NeuralNetworks">NeuralNetworks</a>，我们在0.16.1版本基础上稍作修改，即可完成本书的例子。</p>
<blockquote>
<p>请fork作者的NeuralNetworks，将<code>multilayer_perceptron</code>文件夹里的<code>.py</code>文件复制到<code>sklearn/neural_network</code>文件夹里，然后将对<code>__init__.py</code>文件做如下修改即可：</p>
<div class="highlight"><pre><span></span><span class="c1"># __init__.py</span>
<span class="kn">from</span> <span class="nn">.rbm</span> <span class="kn">import</span> <span class="n">BernoulliRBM</span>

<span class="kn">from</span> <span class="nn">.multilayer_perceptron</span> <span class="kn">import</span> <span class="n">MultilayerPerceptronClassifier</span>
<span class="kn">from</span> <span class="nn">.multilayer_perceptron</span> <span class="kn">import</span> <span class="n">MultilayerPerceptronRegressor</span>

<span class="n">__all__</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"BernoulliRBM"</span><span class="p">,</span>
           <span class="s2">"MultilayerPerceptronClassifier"</span><span class="p">,</span>
           <span class="s2">"MultilayerPerceptronRegressor"</span><span class="p">]</span>
</pre></div>
<p>另外，在Linux和Mac OS系统里，复制<code>.py</code>文件的权限记得改成<code>chmod 644</code></p>
</blockquote>
<p>首先，我们建议一个简单的二分分类数据集表示XOR，然后用交叉检验分割成训练集和测试集：</p>

</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In [1]:</div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="kn">from</span> <span class="nn">sklearn.cross_validation</span> <span class="k">import</span> <span class="n">train_test_split</span>
<span class="kn">from</span> <span class="nn">sklearn.neural_network</span> <span class="k">import</span> <span class="n">MultilayerPerceptronClassifier</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
<span class="n">y</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">1000</span>
<span class="n">X</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">]]</span> <span class="o">*</span> <span class="mi">1000</span><span class="p">)</span>
<span class="n">X_train</span><span class="p">,</span> <span class="n">X_test</span><span class="p">,</span> <span class="n">y_train</span><span class="p">,</span> <span class="n">y_test</span> <span class="o">=</span> <span class="n">train_test_split</span><span class="p">(</span><span class="n">X</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">random_state</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
</pre></div>

</div>
</div>
</div>

</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>然后，我们将<code>MultilayerPerceptronClassifier</code>类实例化。用<code>n_hidden</code>设置神经网络架构中隐藏层的层数。我们将隐藏层的层数设置为两层。<code>MultilayerPerceptronClassifier</code>类自动创建两个输入单元和一个输出单元。在多元分类问题中分类器会为每一个可能的类型创建一个输出。</p>
<p>选择神经网络架构是很复杂的事情。确定隐藏单元和隐藏层的数量有一些首要原则，但是都没有必然的依据。隐藏单元的数量由样本数量，训练数据的噪声，要被近似的函数复杂性，隐藏单元的激励函数，学习算法和使用的正则化方法决定。实际上，架构的效果只能通过交叉检验得出。</p>
<p>我们通过<code>fit()</code>函数训练模型：</p>

</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In [3]:</div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">clf</span> <span class="o">=</span> <span class="n">MultilayerPerceptronClassifier</span><span class="p">(</span><span class="n">hidden_layer_sizes</span><span class="o">=</span><span class="p">[</span><span class="mi">2</span><span class="p">],</span>
                                    <span class="n">activation</span><span class="o">=</span><span class="s1">'logistic'</span><span class="p">,</span>
                                    <span class="n">algorithm</span><span class="o">=</span><span class="s1">'sgd'</span><span class="p">,</span>
                                    <span class="n">random_state</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="n">clf</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">X_train</span><span class="p">,</span> <span class="n">y_train</span><span class="p">)</span>
</pre></div>

</div>
</div>
</div>

<div class="output_wrapper">
<div class="output">


<div class="output_area">
<div class="prompt output_prompt">Out[3]:</div>


<div class="output_text output_subarea output_execute_result">
<pre>MultilayerPerceptronClassifier(activation='logistic', algorithm='sgd',
                alpha=1e-05, batch_size=200, hidden_layer_sizes=[2],
                learning_rate='constant', learning_rate_init=0.5,
                max_iter=200, power_t=0.5, random_state=3, shuffle=False,
                tol=1e-05, verbose=False, warm_start=False)</pre>
</div>

</div>

</div>
</div>

</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>最后，我们打印估计模型对测试集预测的准确率和一些手工输入的预测结果。预测测试集的结果表明，这个人工神经网络可以完美的近似XOR函数：</p>

</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In [5]:</div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s1">'层数：</span><span class="si">%s</span><span class="s1">，输出单元数量：</span><span class="si">%s</span><span class="s1">'</span> <span class="o">%</span> <span class="p">(</span><span class="n">clf</span><span class="o">.</span><span class="n">n_layers_</span><span class="p">,</span> <span class="n">clf</span><span class="o">.</span><span class="n">n_outputs_</span><span class="p">))</span>
<span class="n">predictions</span> <span class="o">=</span> <span class="n">clf</span><span class="o">.</span><span class="n">predict</span><span class="p">(</span><span class="n">X_test</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">'准确率：</span><span class="si">%s</span><span class="s1">'</span> <span class="o">%</span> <span class="n">clf</span><span class="o">.</span><span class="n">score</span><span class="p">(</span><span class="n">X_test</span><span class="p">,</span> <span class="n">y_test</span><span class="p">))</span>
<span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">p</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">predictions</span><span class="p">[:</span><span class="mi">10</span><span class="p">]):</span>
    <span class="nb">print</span><span class="p">(</span><span class="s1">'真实值：</span><span class="si">%s</span><span class="s1">，预测值：</span><span class="si">%s</span><span class="s1">'</span> <span class="o">%</span> <span class="p">(</span><span class="n">y_test</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">p</span><span class="p">))</span>
</pre></div>

</div>
</div>
</div>

<div class="output_wrapper">
<div class="output">


<div class="output_area">
<div class="prompt"></div>
<div class="output_subarea output_stream output_stdout output_text">
<pre>层数：3，输出单元数量：1
准确率：1.0
真实值：1，预测值：1
真实值：1，预测值：1
真实值：1，预测值：1
真实值：0，预测值：0
真实值：1，预测值：1
真实值：0，预测值：0
真实值：0，预测值：0
真实值：1，预测值：1
真实值：0，预测值：0
真实值：1，预测值：1
</pre>
</div>
</div>

</div>
</div>

</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="手写数字识别">手写数字识别<a class="anchor-link" href="10-from-the-perceptron-to-artificial-neural-networks.html#%E6%89%8B%E5%86%99%E6%95%B0%E5%AD%97%E8%AF%86%E5%88%AB">¶</a>
</h3>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>在上一章我们介绍过用支持向量机识别MNIST数据集里面的手写数字。下面我们用人工神经网络来识别：</p>

</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In [6]:</div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="kn">from</span> <span class="nn">sklearn.datasets</span> <span class="k">import</span> <span class="n">load_digits</span>
<span class="kn">from</span> <span class="nn">sklearn.cross_validation</span> <span class="k">import</span> <span class="n">train_test_split</span><span class="p">,</span> <span class="n">cross_val_score</span>
<span class="kn">from</span> <span class="nn">sklearn.pipeline</span> <span class="k">import</span> <span class="n">Pipeline</span>
<span class="kn">from</span> <span class="nn">sklearn.preprocessing</span> <span class="k">import</span> <span class="n">StandardScaler</span>
<span class="kn">from</span> <span class="nn">sklearn.neural_network.multilayer_perceptron</span> <span class="k">import</span> <span class="n">MultilayerPerceptronClassifier</span>
</pre></div>

</div>
</div>
</div>

</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>首先我们用<code>load_digits</code>函数加载数据集。因为我们要在交叉验证期间拷贝（fork）进程，所以程序要放在<code>main()</code>函数里运行：</p>

</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In [7]:</div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s1">'__main__'</span><span class="p">:</span>
    <span class="n">digits</span> <span class="o">=</span> <span class="n">load_digits</span><span class="p">()</span>
    <span class="n">X</span> <span class="o">=</span> <span class="n">digits</span><span class="o">.</span><span class="n">data</span>
    <span class="n">y</span> <span class="o">=</span> <span class="n">digits</span><span class="o">.</span><span class="n">target</span>
</pre></div>

</div>
</div>
</div>

</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>在人工神经网络里，放大特征非常重要，因为这样可以让算法更快的收敛。在用<code>MultilayerPerceptronClassifier</code>训练模型前，我们用<code>Pipeline</code>类放大数据。这个神经网络包括一个输入层和一个输出层，两个隐藏层，其中一个有150个单元，另一个有100个单元。我们还增加了正则化<code>alpha</code>超参数的值。最后，我们打印三个交叉验证组合的预测准确率。</p>

</div>
</div>
</div>
<div class="cell border-box-sizing code_cell rendered">
<div class="input">
<div class="prompt input_prompt">In [8]:</div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">pipeline</span> <span class="o">=</span> <span class="n">Pipeline</span><span class="p">([</span>
                    <span class="p">(</span><span class="s1">'ss'</span><span class="p">,</span> <span class="n">StandardScaler</span><span class="p">()),</span>
                    <span class="p">(</span><span class="s1">'mlp'</span><span class="p">,</span> <span class="n">MultilayerPerceptronClassifier</span><span class="p">(</span><span class="n">hidden_layer_sizes</span><span class="o">=</span><span class="p">[</span><span class="mi">150</span><span class="p">,</span> <span class="mi">100</span><span class="p">],</span> <span class="n">alpha</span><span class="o">=</span><span class="mf">0.1</span><span class="p">))</span>
                    <span class="p">])</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">'准确率： </span><span class="si">%s</span><span class="s1">'</span> <span class="o">%</span> <span class="n">cross_val_score</span><span class="p">(</span><span class="n">pipeline</span><span class="p">,</span> <span class="n">X</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">n_jobs</span><span class="o">=-</span><span class="mi">1</span><span class="p">))</span>
</pre></div>

</div>
</div>
</div>

<div class="output_wrapper">
<div class="output">


<div class="output_area">
<div class="prompt"></div>
<div class="output_subarea output_stream output_stdout output_text">
<pre>准确率： [ 0.8654485   0.87646077  0.87248322]
</pre>
</div>
</div>

</div>
</div>

</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>人工神经网络的平均准确率与支持向量机一致。增加隐藏单元和隐藏层，运用网格搜索，会进一步提供模型的准确率。</p>

</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="总结">总结<a class="anchor-link" href="10-from-the-perceptron-to-artificial-neural-networks.html#%E6%80%BB%E7%BB%93">¶</a>
</h3>
</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>本章我们介绍了人工神经网络，一种通过人工神经元的组合来表述复杂函数的强大的分类和回归模型。本文介绍的有向无环图称为前馈人工神经网络。多层感知器就是一种前馈人工神经网络，其每一次都完全连接后面一层。带一个隐藏层和若干隐藏单元的MLP是一种通用函数近似器。它可以表示任何连续函数，尽管它未必能够自动的学习到适当的权重。我们还介绍了网络的隐藏层如何表示不可见的变量，以及如何用反向传播算法学习权重。最后，我们用scikit-learn的多次感知器<code>MultilayerPerceptronClassifier</code>类完成了XOR函数近似和MNIST数据集的手写数字识别。</p>

</div>
</div>
</div>
<div class="cell border-box-sizing text_cell rendered">
<div class="prompt input_prompt">
</div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>这是本书的最后一章。我们介绍许多模型，学习算法，效果评估方法，以及这些理论在scikit-learn中的实现。第一章，我们把机器学习描述成一种通过经验改善任务学习效果的过程。然后，我们通过一些例子演示常见的机器学习任务，学习经验和效果评估方法。我们介绍过匹萨价格与直接的回归案例和垃圾短信分类案例。我们通过颜色聚类压缩图片，聚类SURF描述器识别猫和狗的照片。我们用主成分分析做面部识别，用随机森林决策树拦截网页上的广告图片，还用支持向量机和人工神经网络识别手写数字。感谢你的阅读，希望你可以用scikit-learn和书中案例解决自己的问题。</p>

</div>
</div>
</div>
    </div>
  </div>

    </div>
    <aside class="postpromonav"><nav><ul itemprop="keywords" class="tags">
<li><a class="tag p-category" href="../categories/chs.html" rel="tag">CHS</a></li>
            <li><a class="tag p-category" href="../categories/ipython.html" rel="tag">ipython</a></li>
            <li><a class="tag p-category" href="../categories/machine-learning.html" rel="tag">Machine Learning</a></li>
            <li><a class="tag p-category" href="../categories/python.html" rel="tag">Python</a></li>
        </ul>
<ul class="pager hidden-print">
<li class="previous">
                <a href="dlott-15078-2015-07-08-report.html" rel="prev" title="大乐透15078期(2015-07-08)数据分析报告">Previous post</a>
            </li>
            <li class="next">
                <a href="0-perface.html" rel="next" title="0-perface">Next post</a>
            </li>
        </ul></nav></aside><script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"> </script><script type="text/x-mathjax-config">
MathJax.Hub.Config({
    tex2jax: {
        inlineMath: [ ['$','$'], ["\\(","\\)"] ],
        displayMath: [ ['$$','$$'], ["\\[","\\]"] ],
        processEscapes: true
    },
    displayAlign: 'center', // Change this to 'center' to center equations.
    "HTML-CSS": {
        styles: {'.MathJax_Display': {"margin": 0}}
    }
});
</script></article>
</div>
        <!--End of body content-->

        <footer id="footer">
            Contents © 2017         <a href="mailto:muxuezi@gmail.com">Tao Junjie</a> - Powered by         <a href="https://getnikola.com" rel="nofollow">Nikola</a>         
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0">
<img alt="Creative Commons License BY-NC-SA" style="border-width:0; margin-bottom:12px;" src="http://i.creativecommons.org/l/by-nc-sa/4.0/80x15.png"></a>
            
        </footer>
</div>
</div>


            <script src="../assets/js/all-nocdn.js"></script><script>$('a.image-reference:not(.islink) img:not(.islink)').parent().colorbox({rel:"gal",maxWidth:"100%",maxHeight:"100%",scalePhotos:true});</script><!-- fancy dates --><script>
    moment.locale("en");
    fancydates(0, "YYYY-MM-DD HH:mm");
    </script><!-- end fancy dates --><script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','//www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-51330059-1', 'auto');
  ga('send', 'pageview');

</script>
</body>
</html>
